Celestin Apprentice 4/Apprentice-Release4.iso/Source Code/Pascal/Applications/NIH Image 1.59/1.59 Source/Camera.p

Text File | 1995-10-31 | 42.3 KB | 1,542 lines | [TEXT/PJMM]

unit Camera;

{Routines used by the NIH Image to support Data Translation
and Scion (LG-3, AG-5 or VG-5) frame grabber cards, and
QuickTime compatible digitizers.}

interface


    uses
        Memory, QuickDraw, Packages, Menus, Events, Fonts, Scrap, ToolUtils,
        OSUtils,Resources, Errors, Palettes, QuickTimeComponents, GestaltEqu,
        globals, Utilities, Graphics, File1, Analysis;


    function DoAveragingOptions: boolean;
    procedure AverageFrames;
    procedure GetFrame;
    procedure CaptureAndDisplayFrame;
    procedure HighlightPixels;
    procedure ShowTriggerMessage;
    procedure StartDigitizing;
    procedure StopDigitizing;
    procedure SetVideoChannel;
    function GetFGPixel (h, v: integer): integer;
    procedure WaitForTrigger;
    procedure ShowChannel;
    procedure ShowVideoControl;
    procedure UpdateVideoControl;
    procedure DoVideoControl (item: integer);
    procedure SelectCameraWindow;
    procedure SetOffset (var offset, gain: integer);
    procedure SetGain (var offset, gain: integer);
    procedure ShowOffsetAndGain (offset, gain: integer);
    procedure ShowVideoDialog;



implementation

type
    IntPtr = ^integer;

var
    SavePicBaseAddr: ptr;
    StopFlagLoc: IntPtr;


procedure GetGrabDepth(var bitDepth: LongInt; var vdigInfo: DigitizerInfo);
begin
    if VDGetDigitizerInfo(vdig, vdigInfo) = noErr then begin
        if DigitizerMode = digitizeGrayscale then begin
            if band(vdigInfo.outputCapabilityFlags, digiOutDoes8) <> 0 then
                bitDepth := 8 {first choice}
            else if band(vdigInfo.outputCapabilityFlags, digiOutDoes32) <> 0 then
                bitDepth := 32 {second choice}
            else if (band(vdigInfo.outputCapabilityFlags, digiOutDoes16) <> 0) then
                    bitDepth := 16; {last choice}
        end else begin {capture color}
            if band(vdigInfo.outputCapabilityFlags, digiOutDoes32) <> 0 then
                bitDepth := 32 {first choice}
            else if band(vdigInfo.outputCapabilityFlags, digiOutDoes16) <> 0 then
                bitDepth := 16 {second choice}
            else if (band(vdigInfo.outputCapabilityFlags, digiOutDoes8) <> 0) then
                    bitDepth := 8; {last choice}
        end;
    end;
    ShowMessage(StringOf('grab depth=', bitDepth));
end;


procedure SetVideoStandard(var vdigInfo: DigitizerInfo);
var
    err: ComponentResult;
    inFlags, outFlags: LongInt;
begin
    case DigitizerStandard of
        NTSCStd: if band(vdigInfo.inputCapabilityFlags, digiInDoesNTSC) <> 0 then
                        err := VDSetInputStandard(vdig, ntscIn);
        PALStd: if band(vdigInfo.inputCapabilityFlags, digiInDoesPAL) <> 0 then
                        err := VDSetInputStandard(vdig, palIn);
        SECAMStd: if band(vdigInfo.inputCapabilityFlags, digiInDoesSECAM) <> 0 then
                        err := VDSetInputStandard(vdig, secamIn);
        otherwise;
    end;
    err := VDGetCurrentFlags(vdig, inFlags, outFlags);
    if err = noErr then
        if band(inFlags, digiInDoesNTSC) <> 0 then
                        DigitizerStandard := NTSCStd
        else if band(inFlags, digiInDoesPAL) <> 0 then
                        DigitizerStandard := PALStd
        else if band(inFlags, digiInDoesSECAM) <> 0 then
                        DigitizerStandard := SECAMStd;
end;


procedure SetupVdig;
var
    mPtr: MatrixRecordPtr;
    vdErr: ComponentResult;
    vdigInfo: DigitizerInfo;
    DummyMatrixRecord, bitDepth: LongInt;
    err: OSErr;
    flags: GWorldFlags;
    SaveGDevice: GDHandle;
    gwRect: rect;
begin
    SetRect(gwRect, 0, 0, fgWidth, fgHeight);
    bitDepth := 8;
    if VDGetDigitizerInfo(vdig, vdigInfo) = noErr then begin
        GetGrabDepth(bitDepth, vdigInfo);
        SetVideoStandard(vdigInfo);
    end;
    if bitDepth = 8 then
        vdErr := VDSetInputColorSpaceMode(vdig, 0); {grayscale}
    SaveGDevice := GetGDevice;
    SetGDevice(osGDevice);
    if bitDepth = 8 then
        GWorldLUT := GetCTable(40) {grayscale LUT}
    else
        GWorldLUT := nil;
    flags := 0;
    err := NewGWorld(osGWorld, bitDepth, gwRect, GWorldLUT, nil, flags);
    SetGDevice(SaveGDevice);
    if err <> NoErr then begin
            PutMemoryAlert;
            CloseVdig;
            exit(SetupVdig);
        end;
    fgPixMap := GetGWorldPixMap(osGWorld);
    if not LockPixels(fgPixMap) then begin
            CloseVdig;
            exit(SetupVdig);
        end;
    DummyMatrixRecord := LongInt(nil);
    mPtr := MatrixRecordPtr(ptr(DummyMatrixRecord));
    vdErr := VDSetPlayThruDestination(vdig, fgPixMap, gwRect, MatrixRecord(mPtr^), nil);
    if vdErr <> noErr then begin
        CloseVdig;
        PutError(StringOf('Video digitizer error ', vdErr));
    end;
end;


procedure LookForVDig;
{Look for a QuickTime video digitizer component}
var
    result: LongInt;
    videoDesc: ComponentDescription;
    srcRrect: rect;
    vdErr: ComponentResult;
    vdigID: Component;
begin
    if Gestalt(gestaltQuickTime, result) <> noErr then begin
        ShowMessage('No QuickTime');
        exit(LookForVDig);
    end;
    videoDesc.componentType := VideoDigitizerComponentType;
    videoDesc.componentSubType := OSType(0); {any subtype}
    if UseBuiltinDigitizer then
        videoDesc.componentManufacturer := 'appl'
    else
        videoDesc.componentManufacturer := OSType(0);
    videoDesc.componentFlags := 0;
    videoDesc.componentFlagsMask := 0;
    vdigID :=FindNextComponent(Component(0), videoDesc);
    if vdigID = Component(0) then begin
        videoDesc.componentManufacturer := OSType(0); {any manufacturer}
        vdigID :=FindNextComponent(Component(0), videoDesc);
        if vdigID = Component(0) then begin
            ShowMessage('No vdig found');
            exit(LookForVDig);
        end;
    end;
    vdig := OpenComponent(vdigID);
    if vdig = nil then begin
      ShowMessage('Unable to open vdig');
        exit(LookForVDig);
    end;
    vdErr := VDGetDigitizerRect(vdig, srcRrect);
    {vdErr := VDGetActiveSrcRect(vdig, 0, srcRrect);}
    if vdErr = noErr then with srcRrect do begin
        fgWidth := (right - left) div fgScale;
        fgHeight := (bottom - top) div fgScale;
    end else begin
        fgWidth := 320;
        fgHeight := 240;
    end;
    FrameGrabber := QTvdig;
    SetupVdig;
end;


procedure CorrectShadingOfLine (PicPtr, BFPtr: ptr; width, BFMean: integer);
{$IFC PowerPC}
VAR
  PicLine,BFLine:LinePtr;
  i,value:LongInt;
BEGIN
  PicLine:=LinePtr(PicPtr);
  BFLine:=LinePtr(BFPtr);
  FOR i:=0 TO width-1 DO BEGIN
    value:=PicLine^[i];
    value:=255-value;
    value:=(value * BFMean + (BFLine^[i] div 2)) DIV BFLine^[i];
    IF value>254 THEN value:=254;
    IF value<1 THEN value:=1;
    PicLine^[i]:=255-value;
  END;
END;
{$ELSEC}
  {a0=data pointer}
  {a1=blank field data pointer}
  {d0=count}
  {d1=pixel value}
  {d2=blank field pixel value}
  {d3=blank field mean}
  {d4=temp}
  {d5=max pixel value(245)}
  {d6=min pixel value(1)}
    inline
        $4E56, $0000, {   link    a6,#0}
        $48E7, $FEC0, {   movem.l    a0-a1/d0-d6,-(sp)}
        $206E, $000C, {   move.l    12(a6),a0}
        $226E, $0008, {   move.l    8(a6),a1}
        $4280,       {   clr.l    d0}
        $302E, $0006, {   move.w    6(a6),d0}
        $362E, $0004, {   move.w    4(a6),d3}
        $2A3C, $0000, $00FE, {   move.l    #254,d5}
        $2C3C, $0000, $0001, {   move.l    #1,d6}
        $5380,       {   subq.l    #1,d0}
        $4281,       {   clr.l    d1}
        $4282,       {   clr.l    d2}
        $1210,       {L1    move.b    (a0),d1}
        $1419,       {   move.b    (a1)+,d2}
        $4601,       {   not.b    d1}
        $C2C3,       {   mulu.w    d3,d1}
        $2802,       {   move.l    d2,d4}
        $E244,       {   asr.w    #1,d4}
        $D284,       {   add.l    d4,d1}
        $82C2,       {   divu.w    d2,d1}
        $B245,       {   cmp.w    d5,d1}
        $6F02,       {   ble.s    L2}
        $3205,       {   move.w    d5,d1}
        $B246,       {L2    cmp.w    d6,d1}
        $6C02,       {   bge.s    L3}
        $3206,       {   move.w    d6,d1}
        $4601,       {L3    not.b    d1}
        $10C1,       {   move.b    d1,(a0)+}
        $51C8, $FFDE, {   dbra    d0,L1}
        $4CDF, $037F, {   movem.l    (sp)+,a0-a1/d0-d6}
        $4E5E,       {   unlk    a6}
        $DEFC, $000C; {   add.w    #12,sp}
{$ENDC}


    procedure CorrectShading;
        var
            i, tag, width: integer;
            offset, NextUpdate: LongInt;
            p1, p2: ptr;
            str: str255;
            MaskRect:rect;
    begin
        with info^ do begin
                if ImageSize <> BlankFieldInfo^.ImageSize then begin
                        beep;
                        exit(CorrectShading);
                    end;
                ShowWatch;
                tag:=0;
                NextUpdate:=TickCount+6;
                width:=PicRect.right;
                p1 := PicBaseAddr;
                p2 := BlankFieldInfo^.PicBaseAddr;
                for i := 1 to nLines do begin
                        CorrectShadingOfLine(p1, p2, PixelsPerLine, BlankFieldMean);
                        p1 := ptr(ord4(p1) + info^.BytesPerRow);
                        p2 := ptr(ord4(p2) + BlankFieldInfo^.BytesPerRow);
                    if TickCount>=NextUpdate then begin
                            SetRect(MaskRect, 0, tag, width, i);
                            UpdateScreen(MaskRect);
                            tag:=i;
                            NextUpdate:=TickCount+6;
                        end;
                    end;
                SetRect(MaskRect, 0, tag, width, nLines);
                UpdateScreen(MaskRect);
                str := title;
                if SpatiallyCalibrated then
                    str := concat(str, chr($13)); {Black Diamond}
                if fit <> uncalibrated then
                    str := concat(str, '');
                if wptr <> nil then
                    SetWTitle(wptr, concat(str, ' (Corrected)'));
            end;
    end;


    procedure StopDigitizing;
    begin
        if digitizing then
            with info^ do begin
                    ShowFrameRate('', fgStartTicks, fgFrameCount);
                    CopyOffscreen(fgPixMap, osPort^.portPixMap, PicRect, PicRect);
                    if vdig <> nil then
                        UpdatePicWindow;
                    SetMenuItemText(SpecialMenuH, StartItem, 'Start Capturing');
                    Digitizing := false;
                    ContinuousHistogram := false;
                    with info^ do
                        if PictureType = FrameGrabberType then begin
                                title := 'Camera';
                                UpdateTitleBar;
                                if HighlightSaturatedPixels then
                                    LoadLUT(ctable);
                            end;
                    if (ScreenDepth<>8) and HighlightSaturatedPixels then
                        UpdatePicWindow;
                    if (BlankFieldInfo <> nil) and not OptionKeyDown then
                        CorrectShading;
                end;
    end;


    procedure GetFrame;
        var
            ticks, timeout: LongInt;
            temp:integer;
            vdigErr: ComponentResult;
    begin
            case FrameGrabber of

                ScionLG3, ScionVG5f:
                    if ExternalTrigger then begin {Wait for trigger}
                            ControlReg^ := $90;
                            repeat
                                if button then
                                    ExternalTrigger := false;
                            until (band(ControlReg^, $80) = $80) or not ExternalTrigger;
                            ControlReg^ := 0;
                            if Digitizing then
                                StopDigitizing;
                            UpdateVideoControl;
                        end {if External Trigger}
                    else begin
                            TimeOut := TickCount + 30;  {1/2sec. timeout}
                            ControlReg^ := $80; {Start frame capture}
                            while band(ControlReg^, $80) = 0 do begin    {Wait for it to complete}
                                    if TickCount > TimeOut then begin
                                            ControlReg^ := 0;
                                            leave
                                        end;
                                end;
                            ControlReg^ := 0;
                        end;

            ScionAG5:
                    if ExternalTrigger then begin {Wait for trigger}
                            ControlReg^ := bor(bor(ord(AG5GrabMode), $90), bsl(ord(AG5LutMode and not ControlKeyDown), 2));
                            repeat
                                if button then
                                    ExternalTrigger := false;
                            until (band(ControlReg^, $80) = $80) or not ExternalTrigger;
                            ControlReg^ := 0;
                            if Digitizing then
                                StopDigitizing;
                            UpdateVideoControl;
                        end {if External Trigger}
                    else begin
                            TimeOut := TickCount + 30;  {1/2sec. timeout}
                            ControlReg^ := bor(bor(ord(AG5GrabMode), $80), bsl(ord(AG5LutMode and not ControlKeyDown), 2)); {Start frame capture}
                            repeat
                                if TickCount > TimeOut then
                                    leave;
                                temp:=ControlReg^; {ppc-bug}
                            until band(temp, $80) <> 0; {Wait for it to complete}
                            ControlReg^ := 0;
                        end;

            QuickCapture:
                if ExternalTrigger then begin {Wait for trigger}
                        ControlReg^ := $82; {Set Busy and External Trigger Enable bits}
                        repeat
                            if button then
                                ExternalTrigger := false;
                            temp:=ControlReg^; {ppc-bug}
                        until (band(temp, $80) = 0) or not ExternalTrigger;
                        if Digitizing then
                            StopDigitizing;
                        UpdateVideoControl;
                    end {if External Trigger}
                else begin
                        TimeOut := TickCount + 30;  {1/2sec. timeout}
                        ControlReg^ := $80; {Start frame capture by setting busy bit}
                        repeat
                            if TickCount > TimeOut then
                                leave;
                            temp:=ControlReg^; {ppc-bug}
                        until band(temp, $80) = 0; {Wait for frame capture to complete}
                    end;

            QTvdig: begin
                            if ExternalTrigger then begin {Wait for mouse press}
                                repeat
                                until button;
                                ExternalTrigger := false;
                            end;
                            if vdig <> nil then
                                vdigErr := VDGrabOneFrame(vdig);
                    end;

        end; {case}
        fgFrameCount := fgFrameCount + 1;
    end;


    procedure CaptureAndDisplayFrame;
        var
            tPort: GrafPtr;
            SaveGDevice: GDHandle;
    begin
        with info^ do begin
                if (PictureType <> FrameGrabberType) or (PixelsPerLine <> fgWidth) or (nlines <> fgHeight) then begin
                        Digitizing := false;
                        exit(CaptureAndDisplayFrame);
                    end;
                GetFrame;
                SaveGDevice := GetGDevice;
                SetGDevice(GetMainDevice);
                getPort(tPort);
                SetPort(wptr);
                SetFColor(BlackIndex);
                SetBColor(WhiteIndex);
                if (FrameGrabber = QTvdig) and (LUTMode <> grayscale) and (ScreenDepth <= 8) then
                    CopyBits(BitMapHandle(fgPixMap)^^, BitMapHandle(CGrafPtr(wptr)^.PortPixMap)^^, SrcRect, wrect, ditherCopy, nil)
                else
                    CopyBits(BitMapHandle(fgPixMap)^^, BitMapHandle(CGrafPtr(wptr)^.PortPixMap)^^, SrcRect, wrect, srcCopy, nil);
                SetPort(tPort);
                SetGDevice(SaveGDevice);
            end;
    end;


    procedure SetReg (index, value: integer);
        const
            RegOffset = $f5fe0;
        var
            reg: ptr;
    begin
        reg := ptr(fgSlotBase + RegOffset + index * 4);
        reg^ := value;
    end;


    {$ifc PowerPC} {ppc-bug}
    procedure SwapMMUMode(var mode:SignedByte);
    begin
    end;
    {$endc}


    procedure SelectCameraWindow;
  {If there is a Camera window, activate it, otherwise, do nothing.}
        var
            i: integer;
            TempInfo: InfoPtr;
    begin
        for i := 1 to nPics do begin
                TempInfo := pointer(WindowPeek(PicWindow[i])^.RefCon);
                if TempInfo^.PictureType = FrameGrabberType then begin
                        if PicWindow[i] <> nil then begin
                                if OpPending then
                                    KillRoi;
                                SelectWindow(PicWindow[i]);
                                Info := TempInfo;
                                ActivateWindow;
                            end; {if}
                        leave;
                    end; {if}
            end; {for}
    end;


    procedure HighlightPixels;
        var
            lut: MyCSpecArray;
    begin
        with info^ do begin
                lut := ctable;
                lut[1].rgb := Highlight1;
                lut[254].rgb := Highlight254;
                LoadLUT(lut);
            end;
    end;


    procedure ShowTriggerMessage;
    begin
        if ExternalTrigger and (frameGrabber <> noFrameGrabber) then
            ShowMessage(concat('EXTERNAL TRIGGER MODE', crStr, '(Press mouse button to exit)'));
    end;


    procedure StartDigitizing;
        var
            i, width, height: integer;
            trect: rect;
            NewWindow: boolean;
    begin
        if FrameGrabber = NoFrameGrabber then
            LookForVDig;
        if Digitizing then begin
                StopDigitizing;
                if BlankFieldInfo <> nil then
                    wait(15);
                FlushEvents(EveryEvent, 0); {In case user holds key down too long}
                exit(StartDigitizing)
            end;
        if FrameGrabber = NoFrameGrabber then begin
                PutError('Capturing requires a Data Translation, Scion or QuickTime compatible frame grabber.');
                AbortMacro;
                exit(StartDigitizing)
            end;
        if info^.PictureType <> FrameGrabberType then
            SelectCameraWindow;
        NewWindow := false;
        with info^ do
            if (PictureType <> FrameGrabberType) or (PixelsPerLine <> fgWidth) or (nlines <> fgHeight) then begin
                    if not NewPicWindow('Camera', fgWidth, fgHeight) then
                        exit(StartDigitizing);
                    if FrameGrabber = QTvdig then with info^ do begin
                        fgPort := osPort;
                        fgSlotBase := LongInt(PicBaseAddr);
                        fgRowBytes := BytesPerRow;
                    end;
                    NewWindow := true;
                end;
        with info^ do begin
                PictureType := FrameGrabberType;
                if NewWindow and (not EqualRect(SrcRect, PicRect)) then {Center Frame}
                    with SrcRect do begin
                            width := right - left;
                            height := bottom - top;
                            left := (PicRect.right - width) div 2;
                            right := left + width;
                            top := (PicRect.bottom - height) div 2;
                            bottom := top + height;
                        end;
                KillRoi;
                if ScaleToFitWindow then
                    ScaleToFit;
                with SrcRect do begin
                        width := right - left;
                        left := band(left, $fffc);
                        right := left + width;
                    end;
                GetWindowRect(wptr, trect);
                with trect do
                    if band(left, 3) <> 0 then
                        MoveWindow(wptr, band(left, $fffc), top, true); {Forces window to be word aligned}
                with SrcRect do {Prevents bus errors when Camera window moved.}
                    if (top = 0) and (bottom < PicRect.bottom) then begin
                            top := top + 1;
                            bottom := bottom + 1;
                        end;
                ResetFrameGrabber;
                Digitizing := true;
                SetMenuItemText(SpecialMenuH, StartItem, 'Stop Capturing');
                changes := true;
                BinaryPic := false;
                UpdateTitleBar;
                if HighlightSaturatedPixels then
                    HighlightPixels;
            end; {with info}
        fgFrameCount := 0;
        fgStartTicks := TickCount;
        ContinuousHistogram := false;
        ShowTriggerMessage;
    end;


    procedure AddLineToSum (src, dst: ptr; width: LongInt);
{$IFC PowerPC}
        type
            SumLineType = array[0..2047] of integer;
            fptr = ^SumLineType;
        var
            FrameLine: LinePtr;
            SumLine: fptr;
            i: integer;
    begin
        FrameLine := LinePtr(src);
        SumLine := fptr(dst);
        for i := 0 to width - 1 do
            SumLine^[i] := SumLine^[i] + FrameLine^[i];
    end;
{$ELSEC}
inline
{a0=data pointer}
{a1=sum buffer pointer}
{d0=count}
{d1=pixel value}
{d2=temp}
    $4E56, $0000, {link    a6,#0}
    $48E7, $E0C0, {movem.l    a0-a1/d0-d2,-(sp)}
    $206E, $000C, {move.l    12(a6),a0}
    $226E, $0008, {move.l    8(a6),a1}
    $202E, $0004, {move.l    4(a6),d0}
    $5380,              {subq.l    #1,d0}
    $4281,              {clr.l    d1}
    $4282,              {clr.l    d2}
    $1218,              {L1    move.b    (a0)+,d1}
    $3411,              {move.w    (a1),d2}
    $D441,              {add.w      d1,d2}
    $32C2,              {move.w    d2,(a1)+}
    $51C8, $FFF6, {dbra    d0,L1}
    $4CDF, $0307, {movem.l    (sp)+,a0-a1/d0-d2}
    $4E5E,               {unlk    a6}
    $DEFC, $000C; {add.w    #12,sp}
{$ENDC}


function DoAveragingOptions: boolean;
    const
        FramesID = 8;
        VideoRateID = 9;
        SumID = 10;
        ShowID = 11;
        FixID = 12;
        MinID = 13;
        MaxID = 14;
        OnChipID = 15;
    var
        mylog: DialogPtr;
        item, i: integer;
begin
    InitCursor;
    mylog := GetNewDialog(140, nil, pointer(-1));
    if not SumFrames then begin
            ShowIntegratedValues := false;
            FixIntegrationScale := false;
        end;
    SetDNum(MyLog, FramesID, FramesToAverage);
    SetDlogItem(mylog, SumID, ord(SumFrames));
    SetDlogItem(mylog, VideoRateID, ord(VideoRateAveraging));
    SetDlogItem(mylog, ShowID, ord(ShowIntegratedValues));
    SetDlogItem(mylog, FixID, ord(FixIntegrationScale));
    SetDlogItem(mylog, OnChipID, ord(IntegrateOnChip));
    SetDNum(MyLog, MinID, IntegrationMin);
    SetDNum(MyLog, MaxID, IntegrationMax);
    SelectDialogItemText(MyLog, FramesID, 0, 32767);
    repeat
        ModalDialog(nil, item);
        if item = FramesID then
            FramesToAverage := GetDNum(MyLog, FramesID);
        if item = SumID then begin
                SumFrames := not SumFrames;
                if SumFrames then
                    IntegrateOnChip := false
                else begin
                        FixIntegrationScale := false;
                        ShowIntegratedValues := false;
                    end;
                SetDlogItem(mylog, SumID, ord(SumFrames));
                SetDlogItem(mylog, FixID, ord(FixIntegrationScale));
                SetDlogItem(mylog, ShowID, ord(ShowIntegratedValues));
                SetDlogItem(mylog, OnChipID, ord(IntegrateOnChip));
            end;
        if item = VideoRateID then begin
                VideoRateAveraging := not VideoRateAveraging;
                if VideoRateAveraging then
                    IntegrateOnChip := false;
                SetDlogItem(mylog, VideoRateID, ord(VideoRateAveraging));
                SetDlogItem(mylog, OnChipID, ord(IntegrateOnChip));
            end;
        if item = ShowID then begin
                ShowIntegratedValues := not ShowIntegratedValues;
                if ShowIntegratedValues then begin
                        SumFrames := true;
                        IntegrateOnChip := false;
                    end;
                SetDlogItem(mylog, ShowID, ord(ShowIntegratedValues));
                SetDlogItem(mylog, SumID, ord(SumFrames));
                SetDlogItem(mylog, OnChipID, ord(IntegrateOnChip));
            end;
        if item = FixID then begin
                FixIntegrationScale := not FixIntegrationScale;
                if FixIntegrationScale then begin
                        SumFrames := true;
                        IntegrateOnChip := false;
                    end;
                SetDlogItem(mylog, FixID, ord(FixIntegrationScale));
                SetDlogItem(mylog, SumID, ord(SumFrames));
                SetDlogItem(mylog, OnChipID, ord(IntegrateOnChip));
            end;
        if (item = MinID) or (item = MaxID) then begin
                if item = MinID then
                    IntegrationMin := GetDNum(MyLog, MinID)
                else
                    IntegrationMax := GetDNum(MyLog, MaxID);
                SumFrames := true;
                FixIntegrationScale := true;
                IntegrateOnChip := false;
                SetDlogItem(mylog, SumID, ord(SumFrames));
                SetDlogItem(mylog, FixID, ord(FixIntegrationScale));
                SetDlogItem(mylog, OnChipID, ord(IntegrateOnChip));
            end;
        if item = OnChipID then begin
                IntegrateOnChip := not IntegrateOnChip;
                if IntegrateOnChip then begin
                        SumFrames := false;
                        VideoRateAveraging := false;
                        FixIntegrationScale := false;
                        ShowIntegratedValues := false;
                    end;
                SetDlogItem(mylog, OnChipID, ord(IntegrateOnChip));
                SetDlogItem(mylog, SumID, ord(SumFrames));
                SetDlogItem(mylog, VideoRateID, ord(VideoRateAveraging));
                SetDlogItem(mylog, FixID, ord(FixIntegrationScale));
                SetDlogItem(mylog, ShowID, ord(ShowIntegratedValues));
            end;
    until (item = ok) or (item = cancel);
    DisposeDialog(mylog);
    if FramesToAverage < 2 then
        FramesToAverage := 2;
    if IntegrationMin < 0 then
        IntegrationMin := 0;
    if IntegrationMax > 32767 then
        IntegrationMax := 32767;
    if VideoRateAveraging and (item <> cancel) then begin
            if (FrameGrabber <> ScionLG3) and (FrameGrabber <> ScionAG5) then begin
                    VideoRateAveraging := false;
                    PutError('Video rate averaging or summation requires a Scion LG-3 or a Scion AG-5.');
                    DoAveragingOptions := false;
                    exit(DoAveragingOptions);
                end;
            if (FrameGrabber = ScionLG3) and (FramesToAverage > MaxLG3Frames) then begin
                    FramesToAverage := MaxLG3Frames;
                    DoAveragingOptions := false;
                    PutError(concat('This ', long2str(MaxLG3Frames div 2), 'MB LG-3 can capture a maximum of ', long2str(MaxLG3Frames), ' frames at video rates.'));
                    exit(DoAveragingOptions);
                end;
            if (FrameGrabber = ScionAG5) and (FramesToAverage > 127) then begin
                    FramesToAverage := 127;
                    DoAveragingOptions := false;
                    PutError(concat('The AG-5 can average or sum a maximum of 127 frames at video rates.'));
                    exit(DoAveragingOptions);
                end;
        end;
    if IntegrateOnChip and (item <> cancel) then
        if (FrameGrabber <> ScionLG3) and (FrameGrabber <> ScionAG5) and (FrameGrabber <> ScionVG5f)  then begin
                IntegrateOnChip := false;
                PutError('On-chip integration requires a Scion frame grabber.');
                DoAveragingOptions := false;
                exit(DoAveragingOptions);
            end;
    DoAveragingOptions := item <> cancel;
end;



function OddEven: boolean;
{Looks at the the Field Status bit of the Status Register,
which has the same address as Control Register 1. This bit is
high during the odd field and low during the even field.}
begin
 if band(ControlReg^, $10) = $10 then
  OddEven := true
 else
  OddEven := false;
end;


procedure WaitForOdd;
 var
  timeout: LongInt;
begin
 TimeOut := TickCount + 30;  {1/2sec. timeout}
 while OddEven do
  if TickCount > TimeOut then
   Exit(WaitForOdd);
 TimeOut := TickCount + 30;  {1/2sec. timeout}
 while not OddEven do
  if TickCount > TimeOut then
   Exit(WaitForOdd);
end;


procedure IntegrateOn;
{Sets bit 3 (Open Drain Output) of Control Register 1 high
which pulls pin 11 of the 15 pin connector low, causing the
Cohu camera to start integrating.}
begin
 ControlReg^ := $08;
end;


procedure IntegrateOff;
{Sets bit 3 of Control Register 1 low which open circuits
 pin 11, causing the Cohu camera to stop integrating.}
begin
 ControlReg^ := $00;
end;


procedure DoOnChipIntegration;
{Requires a Scion LG-3, a Cohu 4910 series camera, and a cable available from Scion.}
var
    i,StartTicks:LongInt;
    str:str255;
begin
    WaitForOdd;
    IntegrateOn;
    StartTicks := TickCount;
    for i := 1 to FramesToAverage - 1 do begin
        WaitForOdd;
        if (i mod 30) = 0 then
            ShowAnimatedWatch;
        if CommandPeriod then
            leave;
    end;
    IntegrateOff;
    GetFrame;
    RealToString((TickCount - StartTicks) / 60.0, 1, 2, str);
    ShowFrameRate(concat(Long2str(FramesToAverage), ' frames', cr, str, ' seconds', cr), StartTicks, FramesToAverage);
    with info^ do
        CopyOffscreen(fgPixMap, osPort^.portPixMap, RoiRect, RoiRect);
    UpdatePicWindow;
    KillRoi;
    if BlankFieldInfo <> nil then
        CorrectShading;
    if info^.fit<>uncalibrated then
        RemoveDensityCalibration;
end;


procedure DoHardwareAveraging;
{Do averaging or integration at video rates using the Scion Ag-5.}
var
  StartTicks,ActualMin,ActualMax:LongInt;
  str1,str2:str255;
  frame,i:integer;
  roi:rect;
begin
    roi:=info^.RoiRect;
    KillRoi;
    if FramesToAverage > 127 then
        FramesToAverage := 127;
    ExternalTrigger := false;
    AG5GrabMode := GrabNormal;
    GetFrame;
    StartTicks := TickCount;
    AG5GrabMode := GrabSum;
    for frame := 1 to FramesToAverage - 1 do begin
            GetFrame;
        end;
    RealToString((TickCount - StartTicks) / 60.0, 1, 2, str2);
    if not SumFrames then begin
            ConstantReg^ := FramesToAverage;
            AG5GrabMode := GrabDivide;
            GetFrame;
            AG5GrabMode := GrabNormal;
            str1 := '';
        end
    else begin
            ActualMin := Ord4(ScaleLowReg^);
            ActualMax := Ord4(ScaleHighReg^);
            if FixIntegrationScale then begin
                    ScaleLowReg^ := integer(IntegrationMin);
                    ScaleHighReg^ := integer(IntegrationMax);
                end;
            AG5GrabMode := GrabScale;
            GetFrame;
            AG5GrabMode := GrabNormal;
            if FixIntegrationScale then
                str1 := concat('min=', long2str(IntegrationMin), ' (', long2str(ActualMin), ')', cr, 'max=', long2str(IntegrationMax), ' (', long2str(ActualMax), ')', cr)
            else
                str1 := concat('min=', long2str(ActualMin), cr, 'max=', long2str(ActualMax), cr)
        end;
    ShowFrameRate(concat(Long2str(FramesToAverage), ' frames', cr, str1, str2, ' seconds', cr), StartTicks, FramesToAverage);
    with info^ do
        CopyOffscreen(fgPixMap, osPort^.portPixMap, roi, roi);
    UpdatePicWindow;
    if not EqualRect(roi, info^.PicRect) then
        RestoreRoi;
    if BlankFieldInfo <> nil then
        CorrectShading;
    if ShowIntegratedValues then with info^ do begin
            fit := StraightLine;
            nCoefficients := 2;
            coefficient[2] := (ActualMax - ActualMin) / 253.0;
            coefficient[1] := ActualMin - coefficient[2];
            ZeroClip := false;
            UpdateTitleBar;
            if macro then
                GenerateValues;
        end else
            if SumFrames and (info^.fit<>uncalibrated) then
                RemoveDensityCalibration;
    end; {DoAG5HardwareAveraging}


procedure AverageFrames;
    type
        IntPtr = ^integer;
        SumLineType = array[0..2047] of integer;
        sptr = ^SumLineType;
    var
        AutoSelectAll: boolean;
        SelectionSize, FrameBufferSize, offset, StartTicks: LongInt;
        SumBase, src, srcbase, dst, OffscreenBase: ptr;
        str1, str2: str255;
        xLines, xPixelsPerLine, BytesPerLine, frame, line, pixel: integer;
        aline, BlankLine: LineType;
        GrabRect: rect;
        hstart, vstart, wwidth, wheight: integer;
        j, FramesAveraged: integer;
        SrcRowBytes, DstRowBytes, i, value, MinV, MaxV, range, ActualMin, ActualMax: LongInt;
        iptr: IntPtr;
        FrameLine: LinePtr;
        SumLine: sptr;
        SaveBlankFieldInfo: InfoPtr;
        myMMUMode: signedbyte;
begin
    with info^ do
        if PictureType <> FrameGrabberType then begin
                PutError('You must have an active Camera window (created using Start Capturing) in order to average frames.');
                AbortMacro;
                exit(AverageFrames)
            end;
    if NotRectangular or NotinBounds then begin
            AbortMacro;
            exit(AverageFrames);
        end;
    if (not OptionKeyWasDown) and (not macro) then begin
            if not DoAveragingOptions then
                exit(AverageFrames);
        end;
    SaveBlankFieldInfo := BlankFieldInfo;
    BlankFieldInfo := nil; {We don't want to do shading correction now}
    StopDigitizing;
    BlankFieldInfo := SaveBlankFieldInfo;
    OptionKeyWasDown := false;
    if (FrameGrabber <> ScionLG3) and (FrameGrabber <> ScionAG5) then
        VideoRateAveraging := false;
    if (FrameGrabber <> ScionLG3) and (FrameGrabber <> ScionAG5) and (FrameGrabber <> ScionVG5f) then
        IntegrateOnChip := false;
    ShowWatch;
    ShowTriggerMessage;
    AutoSelectAll := not Info^.RoiShowing;
    if AutoSelectAll then
        SelectAll(false);
    WhatToUndo := NothingToUndo;
    ContinuousHistogram := false;
    ResetFrameGrabber;
    if IntegrateOnChip then begin
        DoOnChipIntegration;
        exit(AverageFrames);
    end;
    if VideoRateAveraging and (FrameGrabber=ScionAg5) then begin
        DoHardwareAveraging;
        exit(AverageFrames);
    end;
    DrawLabels('Frame:', 'Total:', '');
    with info^.RoiRect do
        SelectionSize := (ord4(right) - left) * (bottom - top);
    FrameBufferSize := SelectionSize * 2;
    if FrameBufferSize > BigBufSize then begin
            NumToString(FrameBufferSize div 1024, str1);
            NumToString(BigBufSize div 1024, str2);
            str2 := concat(str1, 'K bytes are required, but only ', str2, 'K bytes are available.');
            PutError(concat('There is not enough memory to do the requested frame averaging. ', str2));
            if AutoSelectAll or (BlankFieldInfo <> nil) then
                KillRoi
            else
                ShowRoi;
            exit(AverageFrames)
        end;
    WhatsOnClip := NothingOnClip;
    SumBase := BigBuf;
    with info^, info^.RoiRect do begin
            offset := left + ord4(top) * BytesPerRow;
            OffscreenBase := ptr(ord4(PicBaseAddr) + offset);
            offset := left + ord4(top) * fgRowBytes;
            srcbase := ptr(ord4(ptr(fgSlotBase)) + offset);
            SrcRowBytes := fgRowBytes;
            xLines := bottom - top;
            xPixelsPerLine := right - left;
            BytesPerLine := xPixelsPerLine * 2;
        end; {with}
    for i := 0 to BytesPerLine - 1 do
        BlankLine[i] := WhiteIndex;
    dst := SumBase;
    for line := 1 to xLines do begin {zero buffer}
            BlockMove(@BlankLine, dst, BytesPerLine);
            dst := ptr(ord4(dst) + BytesPerLine);
        end;
    info^.title := 'Camera';
    UpdateTitleBar;
    StartTicks := TickCount;
    if VideoRateAveraging then begin
            if FramesToAverage > MaxLG3Frames then
                FramesToAverage := MaxLG3Frames;
            ExternalTrigger := false;
            BufferReg^ := 0;
            GetFrame;
            StartTicks := TickCount - 2;
            for frame := 1 to FramesToAverage - 1 do begin
                    BufferReg^ := Frame;
                    GetFrame;
                end;
            BufferReg^ := 0;
            RealToString((TickCount - StartTicks) / 60.0, 1, 2, str1);
            ShowFrameRate(concat(Long2str(FramesToAverage), ' frames', crStr, str1, ' seconds', crStr), StartTicks, FramesToAverage);
        end; {if VideoRateAveraging}
    for frame := 0 to FramesToAverage - 1 do begin
            Show2Values(frame + 1, FramesToAverage);
            if VideoRateAveraging then
                BufferReg^ := Frame
            else begin
                GetFrame;
                if FrameGrabber = QTvdig then with info^ do
                CopyOffScreen(fgPixMap, osPort^.portPixMap, roiRect, roiRect);
            end;
            src := srcbase;
            dst := SumBase;
            myMMUMode := 1;
            SwapMMUMode(myMMUMode);
            for line := 1 to xLines do begin
                    AddLineToSum(src, dst, xPixelsPerLine);
                    src := ptr(ord4(src) + SrcRowBytes);
                    dst := ptr(ord4(dst) + BytesPerLine);
                end;
            SwapMMUMode(myMMUMode);
            if CommandPeriod then begin
                    beep;
                    if AutoSelectAll then
                        KillRoi
                    else
                        ShowRoi;
                    exit(AverageFrames);
                end;
        end; {for}
    src := SumBase;
    dst := OffscreenBase;
    DstRowBytes := info^.BytesPerRow;
    if SumFrames then begin
            MinV := 2000000000;
            MaxV := 0;
            iptr := IntPtr(src);
            for i := 1 to SelectionSize do begin
                    value := iptr^;
                    if value > MaxV then
                        MaxV := value;
                    if value < MinV then
                        MinV := value;
                    iptr := IntPtr(ord4(iptr) + 2);
                end;
            ActualMin := MinV;
            ActualMax := MaxV;
            if FixIntegrationScale then begin
                    MinV := IntegrationMin;
                    MaxV := IntegrationMax;
                end;
            range := MaxV - MinV;
            if range <> 0 then
                for line := 1 to xLines do begin
                        SumLine := sptr(src);
                        FrameLine := LinePtr(dst);
                        for j := 0 to xPixelsPerLine - 1 do begin
                                value := ord4(SumLine^[j] - MinV) * 253 div range + 1;
                                if value < 0 then
                                    value := 0;
                                if value > 255 then
                                    value := 255;
                                FrameLine^[j] := value;
                            end;
                        src := ptr(ord4(src) + BytesPerLine);
                        dst := ptr(ord4(dst) + DstRowBytes);
                    end
            else
                beep;
        end
    else
        for line := 1 to xLines do begin
                SumLine := sptr(src);
                FrameLine := LinePtr(dst);
                for j := 0 to xPixelsPerLine - 1 do
                    FrameLine^[j] := SumLine^[j] div FramesToAverage;
                src := ptr(ord4(src) + BytesPerLine);
                dst := ptr(ord4(dst) + DstRowBytes);
            end;
    if not VideoRateAveraging then begin
            if SumFrames then begin
                    if FixIntegrationScale then
                        str1 := concat('min=', long2str(MinV), ' (', long2str(ActualMin), ')', crStr, 'max=', long2str(MaxV), ' (', long2str(ActualMax), ')', crStr)
                    else
                        str1 := concat('min=', long2str(MinV), crStr, 'max=', long2str(MaxV), crStr)
                end
            else
                str1 := '';
            RealToString((TickCount - StartTicks) / 60.0, 1, 2, str2);
            ShowFrameRate(concat(Long2str(FramesToAverage), ' frames', crStr, str1, str2, ' seconds', crStr), StartTicks, FramesToAverage);
        end;
    UpdatePicWindow;
    if AutoSelectAll then
        KillRoi
    else
        ShowRoi;
    if BlankFieldInfo <> nil then
        CorrectShading;
    if ShowIntegratedValues then with info^ do begin
            fit := StraightLine;
            nCoefficients := 2;
            coefficient[2] := (MaxV - MinV) / 253.0;
            coefficient[1] := MinV - coefficient[2];
            nKnownValues := 0;
            ZeroClip := false;
            UpdateTitleBar;
            if macro then
                GenerateValues;
        end else
            if SumFrames and (info^.fit<>uncalibrated) then
                RemoveDensityCalibration;
end;


function GetFGPixel (h, v: integer): integer;
    var
        offset: LongInt;
        p: ptr;
begin
    if FrameGrabber = QTvdig then begin
        GetFGPixel := 0;
        exit(GetFGPixel);
    end;
    with Info^ do begin
            if (h < 0) or (v < 0) or (h >= fgWidth) or (v >= fgHeight) then begin
                    GetFGPixel := WhiteIndex;
                    exit(GetFGPixel);
                end;
            offset := ord4(v) * fgRowBytes + h;
            if offset >= ord4(fgHeight) * fgRowBytes then begin
                    GetFGPixel := WhiteIndex;
                    exit(GetFGPixel);
                end;
            p := ptr(ord4(ptr(fgSlotBase)) + offset);
            GetFGPixel := BAND(p^, 255);
        end;
end;


procedure WaitForTrigger;
begin
    StopDigitizing;
    ShowWatch;
    case FrameGrabber of
        QuickCapture:  begin
                ControlReg^ := BitAnd($82, 255);  {Wait for external trigger and capture one frame}
                repeat
                until (BitAnd(ControlReg^, $80) = $00) or Button;  {Wait for it to complete}
            end;
        ScionLG3, ScionAg5, ScionVG5f:  begin
                ControlReg^ := $90; {Wait for external trigger and capture one frame}
                repeat
                until (BitAnd(ControlReg^, $80) = $80) or Button;  {Wait for it to complete}
            end;
        otherwise
            repeat
            until Button;
    end;
end;


procedure DoVideoSettingsDialog;
{Displays QuickTime video digitizer options dialog box}
    const
        grayID = 6;
        color8ID = 7;
        color24ID = 8;
        fullID = 10;
        oneHalfID = 11;
        oneQuarterID = 12;
        ntscID = 14;
        palID = 15;
        secamID =16;
        builtinID = 17;
    var
        mylog: DialogPtr;
        item, ignore: integer;
        saveScale: integer;
        saveBuiltin: boolean;
        wasDigitizing, WindowClosed: boolean;
        saveStandard: VideoDigitizerStandard;
        saveMode: VideoDigitizerMode;

    procedure SetCaptureModeButtons;
    begin
        SetDlogItem(mylog, grayID, ord(DigitizerMode = digitizeGrayscale));
        SetDlogItem(mylog, color8ID, ord(DigitizerMode = digitizeColor));
        SetDlogItem(mylog, color24ID, ord(DigitizerMode = digitizeRGB));
    end;

    procedure SetSizeButtons;
    begin
        SetDlogItem(mylog, fullID, ord(fgScale = 1));
        SetDlogItem(mylog, oneHalfID, ord(fgScale = 2));
        SetDlogItem(mylog, oneQuarterID, ord(fgScale = 4));
    end;

    procedure SetStandardButtons;
    begin
        SetDlogItem(mylog, ntscID, ord((DigitizerStandard = defaultStd) or (DigitizerStandard = NTSCStd)));
        SetDlogItem(mylog, palID, ord(DigitizerStandard = palStd));
        SetDlogItem(mylog, secamID, ord(DigitizerStandard = secamStd));
    end;

begin
    saveScale := fgScale;
    saveBuiltIn := UseBuiltinDigitizer;
    saveMode := DigitizerMode;
    saveStandard := DigitizerStandard;
    InitCursor;
    mylog := GetNewDialog(320, nil, pointer(-1));
    SetCaptureModeButtons;
    SetSizeButtons;
    SetStandardButtons;
    SetDlogItem(mylog, builtinID, ord(UseBuiltinDigitizer));
    repeat
        ModalDialog(nil, item);
        if item = grayID then begin
            DigitizerMode := digitizeGrayscale;
            SetCaptureModeButtons;
        end;
        if item = color8ID then begin
            DigitizerMode := digitizeColor;
            SetCaptureModeButtons;
        end;
        if item = color24ID then begin
            DigitizerMode := digitizeRGB;
            SetCaptureModeButtons;
        end;
        if item = fullID then begin
            fgScale := 1;
            SetSizeButtons;
        end;
        if item = oneHalfID then begin
            fgScale := 2;
            SetSizeButtons;
        end;
        if item = oneQuarterID then begin
            fgScale := 4;
            SetSizeButtons;
        end;
        if item = ntscID then begin
            DigitizerStandard := ntscStd;
            SetStandardButtons;
        end;
        if item = palID then begin
            DigitizerStandard := palStd;
            SetStandardButtons;
        end;
        if item = secamID then begin
            DigitizerStandard := secamStd;
            SetStandardButtons;
        end;
        if item = builtinID then begin
            UseBuiltinDigitizer := not UseBuiltinDigitizer;
            SetDlogItem(mylog, builtinID, ord(UseBuiltinDigitizer));
        end;
    until (item = ok) or (item = cancel);
    DisposeDialog(mylog);
    if item = cancel then begin
        fgScale := saveScale;
        UseBuiltinDigitizer := saveBuiltIn;
        DigitizerMode := saveMode;
        DigitizerStandard := saveStandard;
        exit(DoVideoSettingsDialog);
    end;
    wasDigitizing := digitizing;
    StopDigitizing;
    WindowClosed := false;
    CloseVdig;
    if (fgScale <> saveScale) or (UseBuiltinDigitizer <> saveBuiltIn) or (DigitizerStandard <> saveStandard) then begin
        SelectCameraWindow;
        with info^ do if PictureType = FrameGrabberType then begin
            changes := false;
            ignore := CloseAWindow(wptr);
            WindowClosed := true;
        end;
    end;
    if FrameGrabber = NoFrameGrabber then
        LookForVDig;
    if wasDigitizing or WindowClosed then
        StartDigitizing;
end;


procedure SetOffset (var offset, gain: integer);
begin
    if offset < 0 then
        offset := 0;
    if offset > 255 then
        offset := 255;
    if offset > gain then
        offset := gain;
    DacLow := offset;
    DacHigh := DacLow + (255 - gain);
end;


procedure SetGain (var offset, gain: integer);
begin
    if gain < 0 then
        gain := 0;
    if gain > 255 then
        gain := 255;
    if gain < DacLow then
        gain := DacLow;
    DacHigh := DacLow + (255 - gain);
end;


procedure ShowChannel;
begin
    SetDlogItem(VideoControl, FirstChannelID, ord(VideoChannel = 0));
    SetDlogItem(VideoControl, FirstChannelID + 1, ord(VideoChannel = 1));
    SetDlogItem(VideoControl, FirstChannelID + 2, ord(VideoChannel = 2));
    SetDlogItem(VideoControl, FirstChannelID + 3, ord(VideoChannel = 3));
end;


procedure UpdateVideoControl;
begin
    if VideoControl <> nil then
        SetDlogItem(VideoControl, TriggerID, ord(ExternalTrigger));
end;


procedure ShowOffsetAndGain (offset, gain: integer);
    var
        str: str255;
begin
    RealToString(offset, 3, 0, str);
    if str[1] = ' ' then
        str[1] := '0';
    if str[2] = ' ' then
        str[2] := '0';
    SetDString(VideoControl, OffsetID, str);
    RealToString(gain, 3, 0, str);
    if str[1] = ' ' then
        str[1] := '0';
    if str[2] = ' ' then
        str[2] := '0';
    SetDString(VideoControl, GainID, str);
end;


procedure ShowVideoControl;
    var
        gain: integer;
begin
    InitCursor;
    VideoControl := GetNewDialog(130, nil, pointer(-1));
    ShowChannel;
    SetDlogItem(VideoControl, InvertID, ord(InvertVideo));
    SetDlogItem(VideoControl, HighlightID, ord(HighlightSaturatedPixels));
    SetDlogItem(VideoControl, TriggerID, ord(ExternalTrigger));
    SetDlogItem(VideoControl, SyncID, ord(SyncMode = SeparateSync));
    gain := 255 - (DacHigh - DacLow);
    ShowOffsetAndGain(DacLow, gain);
end;


    function NoScion:boolean;
    var
        NotFound:boolean;
    begin
        NotFound:=(FrameGrabber <> ScionLG3) and (FrameGrabber<>ScionAg5) and (FrameGrabber<>ScionVG5f);
        if NotFound then PutError('Programmable offset and gain are only supported on Scion frame grabbers.');
        NoScion:=NotFound;
    end;


    procedure DoVideoControl (item: integer);
    var
        i: integer;
        OutOfRange, WasDigitizing: boolean;
        offset, gain, inc, count: integer;


    procedure SetVideoItem (item, value: integer);
    begin
        if VideoControl <> nil then
            SetDlogItem(VideoControl, item, value);
    end;

begin
    InitCursor;
    gain := 255 - (DacHigh - DacLow);
    if (item >= FirstChannelID) and (item <= (FirstChannelID + 3)) then begin
            VideoChannel := item - FirstChannelID;
            if VideoControl <> nil then
                ShowChannel;
            if digitizing then
                ResetFrameGrabber;
        end;
    if item = InvertID then begin
            InvertVideo := not InvertVideo;
            SetVideoItem(InvertID, ord(InvertVideo));
            if digitizing then
                ResetFrameGrabber;
        end;
    if item = HighlightID then begin
            HighlightSaturatedPixels := not HighlightSaturatedPixels;
            SetVideoItem(HighlightID, ord(HighlightSaturatedPixels));
            if digitizing then begin
                    if HighlightSaturatedPixels then
                        HighlightPixels
                    else
                        LoadLUT(info^.ctable);
                end;
        end;
    if item = TriggerID then begin
            ExternalTrigger := not ExternalTrigger;
            case FrameGrabber of
                QuickCapture, ScionLG3, ScionAG5, ScionVG5f:  begin
                        WasDigitizing := digitizing;
                        StopDigitizing;
                        if ExternalTrigger and WasDigitizing then
                            StartDigitizing;
                    end;
                otherwise
                    ExternalTrigger := false;
            end;
            SetVideoItem(TriggerID, ord(ExternalTrigger));
        end;
    if item = SyncID then begin
            if SyncMode <> SeparateSync then
                SyncMode := SeparateSync
            else
                SyncMode := NormalSync;
            case FrameGrabber of
                ScionLG3, ScionAG5, ScionVG5f:
                    if digitizing then
                        ResetFrameGrabber;
                QuickCapture:  begin
                        PutError('Sync is not under program control on the QuickCapure card.');
                        SyncMode := NormalSync;
                        AbortMacro;
                    end;
                otherwise
                    ;
            end;
            SetVideoItem(SyncID, ord(SyncMode = SeparateSync));
        end;
    if (item >= OffsetUpID) and (item <= GainDownID) then begin
            if NoScion then exit(DoVideoControl);
            offset := DacLow;
            inc := 1;
            count := 0;
            repeat
                count := count + 1;
                if count > 2 then
                    inc := 2;
                if count > 4 then
                    inc := 5;
                if count > 8 then
                    inc := 10;
                case item of
                    OffsetUpID:  begin
                            offset := offset + inc;
                            SetOffset(offset, gain);
                        end;
                    OffsetDownID:  begin
                            offset := offset - inc;
                            SetOffset(offset, gain);
                        end;
                    GainUpID:  begin
                            gain := gain + inc;
                            SetGain(offset, gain);
                        end;
                    GainDownID:  begin
                            gain := gain - inc;
                            SetGain(offset, gain);
                        end;
                end; {case}
                ShowOffsetAndGain(DacLow, gain);
                if Digitizing and (count > 1) then begin
                        DacLowReg^ := DacLow;
                        DacHighReg^ := DacHigh;
                        CaptureAndDisplayFrame;
                        if ContinuousHistogram then begin
                                ShowContinuousHistogram;
                                DrawHistogram
                            end
                    end
                else
                    wait(5);
            until not button;
        end;
    if item = ResetID then begin
            if NoScion then exit(DoVideoControl);
            if FrameGrabber=ScionLG3 then begin
                DacLow := DefaultLG3DacLow;
                DacHigh := DefaultLG3DacHigh;
            end else if FrameGrabber = ScionAG5 then begin
                DacLow := DefaultAG5DacLow;
                DacHigh := DefaultAG5DacHigh;
            end else begin
                DacLow := DefaultVG5DacLow;
                DacHigh := DefaultVG5DacHigh;
            end;
            gain := 255 - (DacHigh - DacLow);
            ParamText(long2str(DacLow), long2str(gain), '', '');
            ShowOffsetAndGain(DacLow, gain);
        end;
    if FramesToAverage < 2 then
        FramesToAverage := 2;
    if (FrameGrabber = ScionLG3) or (FrameGrabber=ScionAG5) or (FrameGrabber=ScionVG5f) then begin
            DacLowReg^ := DacLow;
            DacHighReg^ := DacHigh;
        end;
end;


procedure ShowVideoDialog;
begin
    if FrameGrabber = noFrameGrabber then
        LookForVDig;
    if FrameGrabber = QTvdig then
        doVideoSettingsDialog
    else begin
        if VideoControl = nil then
            ShowVideoControl
        else
            SelectWindow(VideoControl);
    end;
end;

end.